use std::collections::HashMap;
use serde::{Serialize};
use serde_json::Value;

/// 数据转换器，用于将结构体数据转换为哈希映射
pub struct DataConverter;

impl DataConverter {
    /// 将数据转换为哈希映射
    ///
    /// # 参数
    /// * `data` - 要转换的数据，必须实现 Serialize 特性
    /// * `skip_nulls` - 是否跳过值为 null 或空的字段
    ///
    /// # 返回值
    /// 返回一个包含键值对的哈希映射
    pub fn convert_to_map<T>(data: &T, skip_nulls: bool) -> HashMap<String, Value>
        where
            T: Serialize,
    {
        // 将数据序列化为 serde_json::Value
        let data_value = serde_json::to_value(data).expect("Failed to serialize data");

        // 确保数据是一个对象类型
        let data_map = data_value.as_object().expect("Data is not an object");
        let mut result = HashMap::new();

        // 遍历数据对象的键值对
        for (key, value) in data_map.iter() {
            match value {
                // 处理字符串类型
                Value::String(s) => {
                    if !skip_nulls || !s.is_empty() {
                        result.insert(key.clone(), Value::String(s.clone()));
                    }
                }
                // 处理数字类型
                Value::Number(n) => {
                    if !skip_nulls || n.is_u64() || n.is_i64() || n.is_f64() {
                        result.insert(key.clone(), Value::Number(n.clone()));
                    }
                }
                // 处理布尔类型
                Value::Bool(b) => {
                    if !skip_nulls || *b {
                        result.insert(key.clone(), Value::Bool(*b));
                    }
                }
                // 处理空值类型
                Value::Null => {
                    if !skip_nulls {
                        result.insert(key.clone(), Value::Null);
                    }
                }
                // 处理数组类型
                Value::Array(arr) => {
                    if !skip_nulls || !arr.is_empty() {
                        result.insert(key.clone(), Value::Array(arr.clone()));
                    }
                }
                // 处理对象类型
                Value::Object(obj) => {
                    if !skip_nulls || !obj.is_empty() {
                        result.insert(key.clone(), Value::Object(obj.clone()));
                    }
                }
            }
        }

        result
    }

    /// 获取结构体的所有字段名称
    ///
    /// # 参数
    /// * `data` - 要转换的数据，必须实现 Serialize 特性
    ///
    /// # 返回值
    /// 返回一个包含字段名称的字符串向量
    pub fn get_field_names<T>(data: &T) -> Vec<String>
    where
        T: Serialize,
    {
        // 将数据序列化为 serde_json::Value
        let data_value = serde_json::to_value(data).expect("Failed to serialize data");

        // 确保数据是一个对象类型
        let data_map = data_value.as_object().expect("Data is not an object");

        // 获取字段名称
        data_map.keys().cloned().collect()
    }
}

fn main() {
    // 示例数据结构
    #[derive(Serialize)]
    struct Example {
        id: i32,
        name: String,
        active: bool,
        tags: Vec<String>,
        metadata: HashMap<String, String>,
    }

    // 创建示例数据
    let example_data = Example {
        id: 1,
        name: "Example".to_string(),
        active: true,
        tags: vec!["tag1".to_string(), "tag2".to_string()],
        metadata: HashMap::new(),
    };

    // 转换数据为哈希映射，跳过 null 或空值
    let converted_map = DataConverter::convert_to_map(&example_data, true);
    log::info!("{:?}", converted_map);

    // 转换数据为哈希映射，不跳过 null 或空值
    let converted_map_no_skip = DataConverter::convert_to_map(&example_data, false);
    log::info!("{:?}", converted_map_no_skip);

    // 获取字段名称
    let field_names = DataConverter::get_field_names(&example_data);
    log::info!("Field names: {:?}", field_names);
}
